// cf-596d
// 题意：给定一维坐标n(<=2000)棵树的坐标，每棵树的高度是h。现在你可以以
//       对半的概率选择砍最左边的树或者最右边的树，然后树会以p的概率向
//       左倒下或者(1-p)的概率向右倒下，如果倒下的时候那个方向上的树和
//       它距离小于h，它也会倒下，以此类推。如果只剩下一颗树的时候就是
//       百分之百会砍它，问最后地面上被树覆盖的长度的期望是多少。
//
// 题解：预处理出连续倒下那个东西，然后用期望的公式来推，就是个简单的
//       区间dp。
//
// run: $exec < input
// opt: 0
// flag: -g
#include <iostream>
#include <iomanip>
#include <algorithm>

int const maxn = 2007;
double f[maxn][maxn][2][2];
int left[maxn], right[maxn];
int a[maxn];
int n, h;
double p;

double dfs(int l, int r, bool tl, bool tr)
{
	if (f[l][r][tl][tr] != -1) return f[l][r][tl][tr];
	if (l > r) return 0;
	double ret = 0;
	if (l == r) {
		ret += p * (tl ? std::min(h, std::max(0, a[l] - a[l - 1] - h)) :
				std::min(h, a[l] - a[l - 1]));
		ret += (1 - p) * (tr ? std::min(h, std::max(0, a[r + 1] - a[r] - h)) :
				std::min(h, a[r + 1] - a[r]));
	} else {
		ret += 0.5 * p * (tl ? std::min(h, std::max(0, a[l] - a[l - 1] - h)) :
				std::min(h, a[l] - a[l - 1]));
		int fr = std::min(right[l], r);
		int len = a[fr] - a[l];
		if (fr < r) len += h;
		else {
			if (tr) len += std::min(h, std::max(0, a[r + 1] - a[r] - h));
			else len += std::min(h, a[r + 1] - a[r]);
		}
		ret += 0.5 * (1 - p) * len;
		ret += 0.5 * (1 - p) * dfs(fr + 1, r, 1, tr);
		ret += 0.5 * p * dfs(l + 1, r, 0, tr);

		ret += 0.5 * (1 - p) * (tr ? std::min(h, std::max(0, a[r + 1] - a[r] - h)) :
				std::min(h, a[r + 1] - a[r]));
		int fl = std::max(l, left[r]);
		len = a[r] - a[fl];
		if (fl > l) len += h;
		else {
			if (tl) len += std::min(h, std::max(0, a[l] - a[l - 1] - h));
			else len += std::min(h, a[l] - a[l - 1]);
		}
		ret += 0.5 * p * len;
		ret += 0.5 * p * dfs(l, fl - 1, tl, 1);
		ret += 0.5 * (1 - p) * dfs(l, r - 1, tl, 0);
	}
	return f[l][r][tl][tr] = ret;
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin >> n >> h >> p;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			for (int k = 0; k < 2; k++)
				for (int t = 0; t < 2; t++) f[i][j][k][t] = -1;
	for (int i = 1; i <= n; i++) std::cin >> a[i];
	std::sort(a + 1, a + n + 1);
	left[1] = 1;
	for (int i = 2; i <= n; i++)
		if (a[i] - a[i - 1] >= h) left[i] = i;
		else left[i] = left[i - 1];
	right[n] = n;
	for (int i = n - 1; i >= 1; i--)
		if (a[i + 1] - a[i] >= h) right[i] = i;
		else right[i] = right[i + 1];

	a[0] = a[1] - 2 * h;
	a[n + 1] = a[n] + 2 * h;
	std::cout << std::fixed << std::setprecision(8) << dfs(1, n, 0, 0) << '\n';
}

